/**
 * API服务模块
 * 统一的API请求处理
 */
class ApiService {
    /**
     * 发送API请求
     * @param {string} url - 请求URL
     * @param {object} options - 请求选项
     * @returns {Promise} API响应
     */
    static async request(url, options = {}) {
        const defaultOptions = {
            method: 'GET',
            headers: {
                'Content-Type': 'application/json',
            },
            credentials: 'include'
        };
        
        // 如果是FormData，不设置Content-Type，让浏览器自动设置
        if (options.body instanceof FormData) {
            delete defaultOptions.headers['Content-Type'];
            // 确保不会重复设置
            if (options.headers && options.headers['Content-Type']) {
                delete options.headers['Content-Type'];
            }
        }
        
        // 从cookie中获取认证token并添加到Authorization header
        const authCookie = document.cookie
            .split('; ')
            .find(row => row.startsWith('auth_token='));
        if (authCookie) {
            const token = authCookie.split('=')[1];
            defaultOptions.headers['Authorization'] = `Bearer ${token}`;
        }
        
        const mergedOptions = { ...defaultOptions, ...options };
        
        // 规范化URL，确保以/api/开头
        let normalizedUrl = url;
        if (!url.startsWith('/api/')) {
            normalizedUrl = `/api${url.startsWith('/') ? url : '/' + url}`;
        }
        
        try {
            const response = await fetch(normalizedUrl, mergedOptions);
            
            // 获取响应数据
            let data;
            const contentType = response.headers.get('content-type');

            // 检查是否是文件下载响应
            const contentDisposition = response.headers.get('content-disposition');
            if (contentDisposition && contentDisposition.includes('attachment')) {
                // 处理文件下载
                const blob = await response.blob();
                const filename = contentDisposition.split('filename=')[1]?.replace(/"/g,) || 'download';

                // 创建下载链接
                const url = window.URL.createObjectURL(blob);
                const a = document.createElement('a');
                a.href = url;
                a.download = filename;
                document.body.appendChild(a);
                a.click();
                document.body.removeChild(a);
                window.URL.revokeObjectURL(url);

                return {
                    success: true,
                    message: '文件下载成功'
                };
            }

            if (contentType && contentType.includes('application/json')) {
                data = await response.json();
            } else {
                data = await response.text();
            }
            
            // 如果响应不是OK，抛出错误（文件下载响应除外）
            if (!response.ok && !(contentDisposition && contentDisposition.includes('attachment'))) {
                throw new Error(data.message || data.error || `HTTP ${response.status}: ${response.statusText}`);
            }
            
            // 标准化响应格式
            if (Array.isArray(data)) {
                // 如果后端直接返回数组，包装成标准格式
                return {
                    success: true,
                    data: data,
                    message: '操作成功'
                };
            }
            
            // 检查是否是新的API响应格式 {code, message, data, timestamp}
            if (data.code === 200 && data.data !== undefined) {
                return {
                    success: true,
                    data: data.data,
                    message: data.message || '操作成功'
                };
            }
            
            // 如果是直接返回的对象（如数据源详情），包装成标准格式
            if (typeof data === 'object' && data !== null && !data.success && (data.id || data.name || data.type)) {
                return {
                    success: true,
                    data: data,
                    message: '操作成功'
                };
            }
            
            // 额外的检查：如果对象有id属性但没有success属性，也包装成标准格式
            if (typeof data === 'object' && data !== null && data.id && !data.success) {
                return {
                    success: true,
                    data: data,
                    message: '操作成功'
                };
            }
            
            // 检查是否是任务列表响应格式 {total, page, page_size, items}
            if (typeof data === 'object' && data !== null && !data.success && data.total !== undefined && data.items !== undefined) {
                return {
                    success: true,
                    data: data,
                    message: '操作成功'
                };
            }
            
            // 检查是否是统计信息响应格式 {total_tasks, pending_tasks, ...}
            if (typeof data === 'object' && data !== null && !data.success && data.total_tasks !== undefined) {
                return {
                    success: true,
                    data: data,
                    message: '操作成功'
                };
            }
            
            // 检查是否是任务详情响应格式 {task, services}
            if (typeof data === 'object' && data !== null && !data.success && data.task !== undefined) {
                return {
                    success: true,
                    data: data,
                    message: '操作成功'
                };
            }
            
            // 如果已经是标准格式，直接返回
            return data;
            
        } catch (error) {
            console.error('API请求失败:', error);
            
            // 对于网络错误，提供更友好的错误信息
            if (error.name === 'TypeError' && error.message.includes('Failed to fetch')) {
                throw new Error('网络连接失败，请检查网络设置');
            }
            
            throw error;
        }
    }
    
    /**
     * 获取数据源列表
     */
    static async getDataSources() {
        return await this.request('/data-sources');
    }
    
    /**
     * 创建数据源
     */
    static async createDataSource(data) {
        return await this.request('/data-sources', {
            method: 'POST',
            body: JSON.stringify(data)
        });
    }
    
    /**
     * 测试数据源连接
     */
    static async testConnection(data) {
        return await this.request('/data-sources/test-connection', {
            method: 'POST',
            body: JSON.stringify(data)
        });
    }
    
    /**
     * 预览数据源数据
     */
    static async previewData(datasourceId, options = {}) {
        return await this.request(`/data-sources/${datasourceId}/preview`, {
            method: 'POST',
            body: JSON.stringify(options)
        });
    }
    
    /**
     * 获取数据源详情
     */
    static async getDataSource(datasourceId) {
        return await this.request(`/data-sources/${datasourceId}`);
    }
    
    /**
     * 更新数据源
     */
    static async updateDataSource(datasourceId, data) {
        return await this.request(`/data-sources/${datasourceId}`, {
            method: 'PUT',
            body: JSON.stringify(data)
        });
    }
    
    /**
     * 删除数据源
     */
    static async deleteDataSource(datasourceId) {
        return await this.request(`/data-sources/${datasourceId}`, {
            method: 'DELETE'
        });
    }
    
    /**
     * 测试数据源连接
     */
    static async testDataSource(datasourceId) {
        return await this.request(`/data-sources/${datasourceId}/test`, {
            method: 'POST'
        });
    }

    /**
     * 获取分析任务列表
     */
    static async getAnalysisTasks(params = {}) {
        const queryParams = new URLSearchParams(params).toString();
        const url = `/analysis-tasks${queryParams ? '?' + queryParams : ''}`;
        console.log('获取分析任务列表，URL:', url, '参数:', params);
        return await this.request(url);
    }

    /**
     * 创建分析任务
     */
    static async createAnalysisTask(data) {
        return await this.request('/analysis-tasks', {
            method: 'POST',
            body: JSON.stringify(data)
        });
    }

    /**
     * 获取分析任务详情
     */
    static async getAnalysisTask(taskId) {
        return await this.request(`/analysis-tasks/${taskId}`);
    }

    /**
     * 更新分析任务
     */
    static async updateAnalysisTask(taskId, data) {
        return await this.request(`/analysis-tasks/${taskId}`, {
            method: 'PUT',
            body: JSON.stringify(data)
        });
    }

    /**
     * 取消分析任务
     */
    static async cancelAnalysisTask(taskId) {
        return await this.request(`/analysis-tasks/${taskId}/cancel`, {
            method: 'POST'
        });
    }

    /**
     * 获取分析任务统计信息
     */
    static async getAnalysisTaskStats() {
        return await this.request('/analysis-tasks/stats/summary');
    }

    /**
     * 获取可用于分析任务的数据源列表
     */
    static async getAnalysisTaskDatasources() {
        return await this.request('/analysis-tasks/datasources/');
    }

    /**
     * 启动分析任务
     */
    static async startAnalysisTask(taskId) {
        return await this.request(`/analysis-tasks/${taskId}/start`, {
            method: 'POST'
        });
    }

    /**
     * 停止分析任务
     */
    static async stopAnalysisTask(taskId) {
        return await this.request(`/analysis-tasks/${taskId}/stop`, {
            method: 'POST'
        });
    }

    /**
     * 重试分析任务
     */
    static async retryAnalysisTask(taskId) {
        return await this.request(`/analysis-tasks/${taskId}/retry`, {
            method: 'POST'
        });
    }

    /**
     * 删除分析任务
     */
    static async deleteAnalysisTask(taskId) {
        return await this.request(`/analysis-tasks/${taskId}`, {
            method: 'DELETE'
        });
    }

    /**
     * 上传Excel文件
     */
    static async uploadExcel(formData) {
        return await this.request('/data-sources/upload-excel', {
            method: 'POST',
            body: formData,
            headers: {} // 让浏览器自动设置Content-Type为multipart/form-data
        });
    }
    
    /**
     * 数据源健康检查
     */
    static async healthCheckDataSources() {
        return await this.request('/data-sources/health-check', {
            method: 'POST'
        });
    }
    
    /**
     * 获取数据源统计信息
     */
    static async getDataSourceStats(datasourceId) {
        return await this.request(`/data-sources/${datasourceId}/stats`);
    }
    
    /**
     * 获取AI服务列表
     */
    static async getAIServices() {
        return await this.request('/ai-services');
    }

    /**
     * 创建AI服务
     */
    static async createAIService(data) {
        return await this.request('/ai-services', {
            method: 'POST',
            body: JSON.stringify(data)
        });
    }

    /**
     * 测试AI服务连接
     */
    static async testAIService(data) {
        return await this.request('/ai-services/test-connection', {
            method: 'POST',
            body: JSON.stringify(data)
        });
    }

    /**
     * 获取统计数据
     */
    static async getStatistics(params = {}) {
        const queryParams = new URLSearchParams(params).toString();
        return await this.request(`/statistics/overview${queryParams ? '?' + queryParams : ''}`);
    }

    /**
     * 获取趋势分析数据
     */
    static async getTrendData(params = {}) {
        const queryParams = new URLSearchParams(params).toString();
        return await this.request(`/statistics/trends${queryParams ? '?' + queryParams : ''}`);
    }

    /**
     * 获取地理分析数据
     */
    static async getGeoAnalysis(params = {}) {
        const queryParams = new URLSearchParams(params).toString();
        return await this.request(`/statistics/geo-distribution${queryParams ? '?' + queryParams : ''}`);
    }
}

// 导出为全局变量
window.ApiService = ApiService;

// 添加模块就绪标记
window.ApiService._isReady = true;
console.log('ApiService模块已加载并就绪');